package com.greenline.push.dal.util;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.NumberUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * 
 * @Type CommonUtils
 * @Desc biz公共类
 * @author 吴敏强
 * @date 2012-9-26
 * @Version V1.0
 */
public class BizCommonUtils {

    private static final Log logger = LogFactory.getLog(BizCommonUtils.class);

    private static final Pattern PATTERN_LETTER = Pattern.compile("[a-zA-Z]+");

    /**
     * 判断是否uuid值
     * 
     * @param strs
     * @return
     */
    public static boolean isUUID(String str) {
        if (StringUtils.isBlank(str)) {
            return false;
        }

        int length = str.length();
        if (str.indexOf(',') == -1 && length > 40) {
            logger.info("_____________字符串不是uuid格式,str=" + str + "_________________");
            return false;
        }

        int j = 0;
        for (int i = 0; i < length; i++) {
            char ch = str.charAt(i);
            if (ch == '-' || ch == ',' || (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z')
                    || (ch >= 'A' && ch <= 'Z')) {
                j = j + 1;
            }
        }
        if (j == length) {
            return true;
        } else {
            logger.info("_____________字符串不是uuid格式,str=" + str + "_________________");
            return false;
        }
    }

    /**
     * 截取给定字符串前半部分内容，比如，“王卓颖（初诊）”按“（”截取后为“王卓颖”。
     * 
     * @author wangbiao
     * @param string
     * @param givenChar
     * @return String
     */
    public static String splitStrWithGivenChar(String string, String givenChar) {
        if (StringUtils.isBlank(string)) {
            return string;
        }
        return string.split(givenChar)[0];
    }

    public static boolean isGbk(char c) {
        String str = String.valueOf(c);
        byte[] b = null;
        try {
            b = str.getBytes("GBK");
        } catch (UnsupportedEncodingException uee) {
            return false;
        }
        if (b.length == 2) {
            int ch0 = b[0]; // 高位字节
            int ch1 = b[1]; // 低位字节

            if (ch0 < 0) {
                ch0 += 256;
            }
            if (ch1 < 0) {
                ch1 += 256;
            }

            if ((ch0 >= 0x81 && ch0 <= 0xA0 || ch0 >= 0xAA && ch0 <= 0xFE) && ch1 >= 0x40 && ch1 <= 0xFE && ch1 != 0x7F) {
                return true;
            }
        }

        return false;
    }

    /**
     * 判断字符串中是否全是中文汉字
     * 
     * @author wangbiao
     * @param c 字符
     * @return true 含有中文汉字
     */
    public static boolean isAllChinese(String str) {
        return CharUtil.isChinese(str);
//        if (StringUtils.isNotBlank(StringUtils.trim(str))) {
//            String trimStr = StringUtils.trim(str);
//            for (int i = 0; i < trimStr.length(); i++) {
//                char c = trimStr.charAt(i);
//                if (!isGbk(c)) {
//                    return false;
//                }
//            }
//            return true;
//        }
//        return false;
    }

    /**
     * 得到随机数
     * 
     * @param setSize 随机数个数
     * @param maxInteger 最大值
     * @return Integer[]
     */
    public static Integer[] getRandomIntArray(int setSize, int maxInteger) {
        Set<Integer> intSet = null;
        if (setSize > maxInteger) {
            // 如果set的Size小于定义的int最大值,会导致死循环
            return null;
        }
        intSet = new HashSet<Integer>();
        Random random = new Random();
        while (intSet.size() < setSize) {
            intSet.add(random.nextInt(maxInteger));
        }
        return (Integer[]) intSet.toArray(new Integer[setSize]);
    }

    /**
     * 空值转换
     * 
     * @param oldStr
     * @param defaultStr
     * @return String
     */
    public static String convertSCStr(String oldStr, String defaultStr) {
        return (StringUtils.isBlank(oldStr) || "null".equals(oldStr)) ? defaultStr : oldStr;
    }

    /**
     * 20120723替换为2012-07-23
     * 
     * @param birthday
     * @return String
     */
    public static String formatDateToYYYY_MM_DD(String date) {
        if (StringUtils.isNotBlank(date) && date.length() >= 8) {
            return date.substring(0, 4) + "-" + date.substring(4, 6) + "-" + date.substring(6, 8);
        }

        return date;
    }

    /**
     * 20120723替换为07-23
     * 
     * @param birthday
     * @return String
     */
    public static String formatDateToMM_DD(String date) {
        if (StringUtils.isNotBlank(date) && date.length() >= 8) {
            return date.substring(4, 6) + "-" + date.substring(6, 8);
        }

        return date;
    }

    /**
     * 判断字符串是否为纯英文字母
     * 
     * @param str
     * @return true false
     */
    public static boolean isPureLetter(String str) {
        Matcher m = PATTERN_LETTER.matcher(StringUtils.trim(str));
        return m.matches();
    }

    /**
     * 读取txt文件内容
     * 
     * @param filePath
     */
    public static String readTxtFile(String filePath) {
        try {
            String encoding = "UTF-8";
            File file = new File(filePath);
            if (file.isFile() && file.exists()) {
                // 判断文件是否存在
                InputStreamReader read = new InputStreamReader(new FileInputStream(file), encoding);
                BufferedReader bufferedReader = new BufferedReader(read);
                String lineTxt = null;
                StringBuilder stringBuilder = new StringBuilder();
                while ((lineTxt = bufferedReader.readLine()) != null) {
                    stringBuilder.append(lineTxt);
                }
                read.close();
                return stringBuilder.toString();
            } else {
                logger.error("找不到指定的文件");
            }
        } catch (Exception e) {
            logger.error("读取文件内容出错" + e.getMessage());
        }
        return null;
    }

    /**
     * 创建多级目录
     * 
     * @param aParentDir String
     * @param aSubDir 以 / 开头
     * @return boolean 是否成功
     */
    public static void creatDirs(String aParentDir, String aSubDir) {
        File aFile = new File(aParentDir);
        if (!aFile.exists()) {
            // 根目录不存在，则创建
            aFile.mkdirs();
        }
        File aSubFile = new File(aParentDir + aSubDir);
        if (!aSubFile.exists()) {
            // 子目录不存在，则创建
            aSubFile.mkdirs();
        }
    }

    /**
     * 根据路径删除指定的目录或文件，无论存在与否
     * 
     * @param sPath 要删除的目录或文件
     * @return 删除成功返回 true，否则返回 false。
     */
    public static boolean deleteFolder(String sPath) {
        boolean flag = false;
        File file = new File(sPath);
        // 判断目录或文件是否存在
        if (!file.exists()) {
            // 不存在
            return flag;
        } else {
            // 判断是否为文件
            if (file.isFile()) {
                // 为文件时调用删除文件方法
                return deleteFile(sPath);
            } else {
                // 为目录时调用删除目录方法
                return deleteDirectory(sPath);
            }
        }
    }

    /**
     * 删除单个文件
     * 
     * @param sPath 被删除文件的文件名
     * @return 单个文件删除成功返回true，否则返回false
     */
    public static boolean deleteFile(String sPath) {
        boolean flag = false;
        File file = new File(sPath);
        // 路径为文件且不为空则进行删除
        if (file.isFile() && file.exists()) {
            file.delete();
            flag = true;
        }
        return flag;
    }

    /**
     * 删除目录（文件夹）以及目录下的文件
     * 
     * @param sPath 被删除目录的文件路径
     * @return 目录删除成功返回true，否则返回false
     */
    public static boolean deleteDirectory(String sPath) {
        // 如果sPath不以文件分隔符结尾，自动添加文件分隔符
        if (!sPath.endsWith(File.separator)) {
            sPath = sPath + File.separator;
        }
        File dirFile = new File(sPath);
        // 如果dir对应的文件不存在，或者不是一个目录，则退出
        if (!dirFile.exists() || !dirFile.isDirectory()) {
            return false;
        }
        boolean flag = true;
        // 删除文件夹下的所有文件(包括子目录)
        File[] files = dirFile.listFiles();
        for (int i = 0; i < files.length; i++) {
            // 删除子文件
            if (files[i].isFile()) {
                flag = deleteFile(files[i].getAbsolutePath());
                if (!flag)
                    break;
            } // 删除子目录
            else {
                flag = deleteDirectory(files[i].getAbsolutePath());
                if (!flag)
                    break;
            }
        }
        if (!flag)
            return false;
        // 删除当前目录
        if (dirFile.delete()) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 解析成整数
     * 
     * @param intStr 整数的字符串形式
     * @return 如果参数为空或不是数字，则返回0
     */
    public static Integer parseInteger(String intStr) {
        return parseInteger(intStr, 0);
    }

    /**
     * 解析成整数
     * 
     * @param intStr 整数的字符串形式
     * @param defaultValue intStr为空或不是数字时的默认值
     * @return 如果参数为空或不是数字，则返回defaultValue
     */
    public static Integer parseInteger(String intStr, Integer defaultValue) {
        Integer i = defaultValue;
        if (NumberUtils.isDigits(intStr)) {
            i = Integer.valueOf(intStr);
        }
        return i;
    }
}
